home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ZSI / TCtimes.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  11KB  |  295 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from ZSI import _copyright, _floattypes, _inttypes, _get_idstr, EvaluateException
  5. from ZSI.TC import TypeCode, SimpleType
  6. from ZSI.wstools.Namespaces import SCHEMA
  7. import operator
  8. import re
  9. import time as _time
  10. from time import mktime as _mktime, localtime as _localtime, gmtime as _gmtime
  11. from datetime import tzinfo as _tzinfo, timedelta as _timedelta, datetime as _datetime
  12. from math import modf as _modf
  13. _niltime = [
  14.     0,
  15.     0,
  16.     0,
  17.     0,
  18.     0,
  19.     0,
  20.     0,
  21.     0,
  22.     0]
  23. _zero = _timedelta(0)
  24. _dstoffset = _stdoffset = _timedelta(seconds = -(_time.timezone))
  25. if _time.daylight:
  26.     _dstoffset = _timedelta(seconds = -(_time.altzone))
  27.  
  28. _dstdiff = _dstoffset - _stdoffset
  29.  
  30. class _localtimezone(_tzinfo):
  31.     
  32.     def dst(self, dt):
  33.         tt = _localtime(_mktime((dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.weekday(), 0, -1)))
  34.         if tt.tm_isdst > 0:
  35.             return _dstdiff
  36.         
  37.         return _zero
  38.  
  39.     
  40.     def tzname(self, dt):
  41.         tt = _localtime(_mktime((dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.weekday(), 0, -1)))
  42.         return _time.tzname[tt.tm_isdst > 0]
  43.  
  44.     
  45.     def utcoffset(self, dt):
  46.         tt = _localtime(_mktime((dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.weekday(), 0, -1)))
  47.         if tt.tm_isdst > 0:
  48.             return _dstoffset
  49.         
  50.         return _stdoffset
  51.  
  52.  
  53.  
  54. class _fixedoffset(_tzinfo):
  55.     
  56.     def __init__(self, offset):
  57.         self._fixedoffset__offset = _timedelta(minutes = offset)
  58.  
  59.     
  60.     def dst(self, dt):
  61.         return _zero
  62.  
  63.     
  64.     def tzname(self, dt):
  65.         return 'server'
  66.  
  67.     
  68.     def utcoffset(self, dt):
  69.         return self._fixedoffset__offset
  70.  
  71.  
  72.  
  73. def _dict_to_tuple(d):
  74.     retval = _niltime[:]
  75.     for k, i in (('Y', 0), ('M', 1), ('D', 2), ('h', 3), ('m', 4)):
  76.         v = d.get(k)
  77.         if v:
  78.             retval[i] = int(v)
  79.             continue
  80.     
  81.     v = d.get('s')
  82.     if v:
  83.         (msec, sec) = _modf(float(v))
  84.         retval[6] = int(round(msec * 1000))
  85.         retval[5] = int(sec)
  86.     
  87.     v = d.get('tz')
  88.     if v and v != 'Z':
  89.         (h, m) = map(int, v.split(':'))
  90.         offset = _localtimezone().utcoffset(_datetime.now())
  91.         local_offset_hour = offset.seconds / 3600
  92.         local_offset_min = offset.seconds % 3600 % 60
  93.         if local_offset_hour > 12:
  94.             local_offset_hour -= 24
  95.         
  96.         if local_offset_hour != h or local_offset_min != m:
  97.             if h < 0:
  98.                 foff = _fixedoffset(-(abs(h) * 60 + m))
  99.             else:
  100.                 foff = _fixedoffset(abs(h) * 60 + m)
  101.             dt = _datetime(retval[0], retval[1], retval[2], retval[3], retval[4], retval[5], 0, foff)
  102.             localdt = dt.astimezone(_localtimezone())
  103.             retval[0] = localdt.year
  104.             retval[1] = localdt.month
  105.             retval[2] = localdt.day
  106.             retval[3] = localdt.hour
  107.             retval[4] = localdt.minute
  108.             retval[5] = localdt.second
  109.         
  110.     
  111.     if d.get('neg', 0):
  112.         retval[0:5] = map(operator.__neg__, retval[0:5])
  113.     
  114.     return tuple(retval)
  115.  
  116.  
  117. class Duration(SimpleType):
  118.     parselist = [
  119.         (None, 'duration')]
  120.     lex_pattern = re.compile('^(?P<neg>-?)P((?P<Y>\\d+)Y)?((?P<M>\\d+)M)?((?P<D>\\d+)D)?(?P<T>T?)((?P<h>\\d+)H)?((?P<m>\\d+)M)?((?P<s>\\d*(\\.\\d+)?)S)?$')
  121.     type = (SCHEMA.XSD3, 'duration')
  122.     
  123.     def text_to_data(self, text, elt, ps):
  124.         if text is None:
  125.             return None
  126.         
  127.         m = Duration.lex_pattern.match(text)
  128.         if m is None:
  129.             raise EvaluateException('Illegal duration', ps.Backtrace(elt))
  130.         
  131.         d = m.groupdict()
  132.         if d['T'] and d['h'] is None and d['m'] is None and d['s'] is None:
  133.             raise EvaluateException('Duration has T without time')
  134.         
  135.         
  136.         try:
  137.             retval = _dict_to_tuple(d)
  138.         except ValueError:
  139.             e = None
  140.             raise EvaluateException(str(e))
  141.  
  142.         if self.pyclass is not None:
  143.             return self.pyclass(retval)
  144.         
  145.         return retval
  146.  
  147.     
  148.     def get_formatted_content(self, pyobj):
  149.         if type(pyobj) in _floattypes or type(pyobj) in _inttypes:
  150.             pyobj = _gmtime(pyobj)
  151.         
  152.         d = { }
  153.         pyobj = tuple(pyobj)
  154.         if 1 in map((lambda x: x < 0), pyobj[0:6]):
  155.             pyobj = map(abs, pyobj)
  156.             neg = '-'
  157.         else:
  158.             neg = ''
  159.         val = '%sP%dY%dM%dDT%dH%dM%dS' % (neg, pyobj[0], pyobj[1], pyobj[2], pyobj[3], pyobj[4], pyobj[5])
  160.         return val
  161.  
  162.  
  163.  
  164. class Gregorian(SimpleType):
  165.     lex_pattern = None
  166.     tag = None
  167.     format = None
  168.     
  169.     def text_to_data(self, text, elt, ps):
  170.         if text is None:
  171.             return None
  172.         
  173.         m = self.lex_pattern.match(text)
  174.         if not m:
  175.             raise EvaluateException('Bad Gregorian: %s' % text, ps.Backtrace(elt))
  176.         
  177.         
  178.         try:
  179.             retval = _dict_to_tuple(m.groupdict())
  180.         except ValueError:
  181.             e = None
  182.             raise 
  183.  
  184.         if self.pyclass is not None:
  185.             return self.pyclass(retval)
  186.         
  187.         return retval
  188.  
  189.     
  190.     def get_formatted_content(self, pyobj):
  191.         if type(pyobj) in _floattypes or type(pyobj) in _inttypes:
  192.             pyobj = _gmtime(pyobj)
  193.         
  194.         d = { }
  195.         pyobj = tuple(pyobj)
  196.         if 1 in map((lambda x: x < 0), pyobj[0:6]):
  197.             pyobj = map(abs, pyobj)
  198.             d['neg'] = '-'
  199.         else:
  200.             d['neg'] = ''
  201.         ms = pyobj[6]
  202.         if not ms or not hasattr(self, 'format_ms'):
  203.             d = {
  204.                 'Y': pyobj[0],
  205.                 'M': pyobj[1],
  206.                 'D': pyobj[2],
  207.                 'h': pyobj[3],
  208.                 'm': pyobj[4],
  209.                 's': pyobj[5] }
  210.             return self.format % d
  211.         
  212.         if ms > 999:
  213.             raise ValueError, 'milliseconds must be a integer between 0 and 999'
  214.         
  215.         d = {
  216.             'Y': pyobj[0],
  217.             'M': pyobj[1],
  218.             'D': pyobj[2],
  219.             'h': pyobj[3],
  220.             'm': pyobj[4],
  221.             's': pyobj[5],
  222.             'ms': ms }
  223.         return self.format_ms % d
  224.  
  225.  
  226.  
  227. class gDateTime(Gregorian):
  228.     parselist = [
  229.         (None, 'dateTime')]
  230.     lex_pattern = re.compile('^(?P<neg>-?)(?P<Y>\\d{4,})-(?P<M>\\d\\d)-(?P<D>\\d\\d)T(?P<h>\\d\\d):(?P<m>\\d\\d):(?P<s>\\d*(\\.\\d+)?)(?P<tz>(Z|([-+]\\d\\d:\\d\\d))?)$')
  231.     (tag, format) = ('dateTime', '%(Y)04d-%(M)02d-%(D)02dT%(h)02d:%(m)02d:%(s)02dZ')
  232.     format_ms = format[:-1] + '.%(ms)03dZ'
  233.     type = (SCHEMA.XSD3, 'dateTime')
  234.  
  235.  
  236. class gDate(Gregorian):
  237.     parselist = [
  238.         (None, 'date')]
  239.     lex_pattern = re.compile('^(?P<neg>-?)(?P<Y>\\d{4,})-(?P<M>\\d\\d)-(?P<D>\\d\\d)(?P<tz>Z|([-+]\\d\\d:\\d\\d))?$')
  240.     (tag, format) = ('date', '%(Y)04d-%(M)02d-%(D)02dZ')
  241.     type = (SCHEMA.XSD3, 'date')
  242.  
  243.  
  244. class gYearMonth(Gregorian):
  245.     parselist = [
  246.         (None, 'gYearMonth')]
  247.     lex_pattern = re.compile('^(?P<neg>-?)(?P<Y>\\d{4,})-(?P<M>\\d\\d)(?P<tz>Z|([-+]\\d\\d:\\d\\d))?$')
  248.     (tag, format) = ('gYearMonth', '%(Y)04d-%(M)02dZ')
  249.     type = (SCHEMA.XSD3, 'gYearMonth')
  250.  
  251.  
  252. class gYear(Gregorian):
  253.     parselist = [
  254.         (None, 'gYear')]
  255.     lex_pattern = re.compile('^(?P<neg>-?)(?P<Y>\\d{4,})(?P<tz>Z|([-+]\\d\\d:\\d\\d))?$')
  256.     (tag, format) = ('gYear', '%(Y)04dZ')
  257.     type = (SCHEMA.XSD3, 'gYear')
  258.  
  259.  
  260. class gMonthDay(Gregorian):
  261.     parselist = [
  262.         (None, 'gMonthDay')]
  263.     lex_pattern = re.compile('^(?P<neg>-?)--(?P<M>\\d\\d)-(?P<D>\\d\\d)(?P<tz>Z|([-+]\\d\\d:\\d\\d))?$')
  264.     (tag, format) = ('gMonthDay', '---%(M)02d-%(D)02dZ')
  265.     type = (SCHEMA.XSD3, 'gMonthDay')
  266.  
  267.  
  268. class gDay(Gregorian):
  269.     parselist = [
  270.         (None, 'gDay')]
  271.     lex_pattern = re.compile('^(?P<neg>-?)---(?P<D>\\d\\d)(?P<tz>Z|([-+]\\d\\d:\\d\\d))?$')
  272.     (tag, format) = ('gDay', '---%(D)02dZ')
  273.     type = (SCHEMA.XSD3, 'gDay')
  274.  
  275.  
  276. class gMonth(Gregorian):
  277.     parselist = [
  278.         (None, 'gMonth')]
  279.     lex_pattern = re.compile('^(?P<neg>-?)---(?P<M>\\d\\d)(?P<tz>Z|([-+]\\d\\d:\\d\\d))?$')
  280.     (tag, format) = ('gMonth', '---%(M)02dZ')
  281.     type = (SCHEMA.XSD3, 'gMonth')
  282.  
  283.  
  284. class gTime(Gregorian):
  285.     parselist = [
  286.         (None, 'time')]
  287.     lex_pattern = re.compile('^(?P<neg>-?)(?P<h>\\d\\d):(?P<m>\\d\\d):(?P<s>\\d*(\\.\\d+)?)(?P<tz>Z|([-+]\\d\\d:\\d\\d))?$')
  288.     (tag, format) = ('time', '%(h)02d:%(m)02d:%(s)02dZ')
  289.     format_ms = format[:-1] + '.%(ms)03dZ'
  290.     type = (SCHEMA.XSD3, 'time')
  291.  
  292. if __name__ == '__main__':
  293.     print _copyright
  294.  
  295.